package edu.princeton;

/*************************************************************************
 *  Compilation:  javac BinaryOut.java
 *  Execution:    java BinaryOut
 *
 *  Write binary data to an output stream, either one 1-bit boolean,
 *  one 8-bit char, one 32-bit int, one 64-bit double, one 32-bit float,
 *  or one 64-bit long at a time. The output stream can be standard
 *  output, a file, an OutputStream or a Socket.
 *
 *  The bytes written are not aligned.
 *
 *************************************************************************/

import java.io.BufferedOutputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.OutputStream;
import java.net.Socket;

/**
 * <i>Binary output</i>. This class provides methods for converting primtive
 * type variables (<tt>boolean</tt>, <tt>byte</tt>, <tt>char</tt>, <tt>int</tt>,
 * <tt>long</tt>, <tt>float</tt>, and <tt>double</tt>) to sequences of bits and
 * writing them to an output stream. The output stream can be standard output, a
 * file, an OutputStream or a Socket. Uses big-endian (most-significant byte
 * first).
 * <p>
 * The client must <tt>flush()</tt> the output stream when finished writing
 * bits.
 * <p>
 * The client should not intermixing calls to <tt>BinaryOut</tt> with calls to
 * <tt>Out</tt>; otherwise unexpected behavior will result.
 */
public final class BinaryOut {

	private BufferedOutputStream out; // the output stream
	private int buffer; // 8-bit buffer of bits to write out
	private int N; // number of bits remaining in buffer

	/**
	 * Create a binary output stream from an OutputStream.
	 */
	public BinaryOut(OutputStream os) {
		out = new BufferedOutputStream(os);
	}

	/**
	 * Create a binary output stream from standard output.
	 */
	public BinaryOut() {
		this(System.out);
	}

	/**
	 * Create a binary output stream from a filename.
	 */
	public BinaryOut(String s) {
		try {
			OutputStream os = new FileOutputStream(s);
			out = new BufferedOutputStream(os);
		} catch (IOException e) {
			e.printStackTrace();
		}
	}

	/**
	 * Create a binary output stream from a Socket.
	 */
	public BinaryOut(Socket socket) {
		try {
			OutputStream os = socket.getOutputStream();
			out = new BufferedOutputStream(os);
		} catch (IOException e) {
			e.printStackTrace();
		}
	}

	/**
	 * Write the specified bit to the binary output stream.
	 */
	private void writeBit(boolean bit) {
		// add bit to buffer
		buffer <<= 1;
		if (bit)
			buffer |= 1;

		// if buffer is full (8 bits), write out as a single byte
		N++;
		if (N == 8)
			clearBuffer();
	}

	/**
	 * Write the 8-bit byte to the binary output stream.
	 */
	private void writeByte(int x) {
		assert x >= 0 && x < 256;

		// optimized if byte-aligned
		if (N == 0) {
			try {
				out.write(x);
			} catch (IOException e) {
				e.printStackTrace();
			}
			return;
		}

		// otherwise write one bit at a time
		for (int i = 0; i < 8; i++) {
			boolean bit = ((x >>> (8 - i - 1)) & 1) == 1;
			writeBit(bit);
		}
	}

	// write out any remaining bits in buffer to the binary output stream,
	// padding with 0s
	private void clearBuffer() {
		if (N == 0)
			return;
		if (N > 0)
			buffer <<= (8 - N);
		try {
			out.write(buffer);
		} catch (IOException e) {
			e.printStackTrace();
		}
		N = 0;
		buffer = 0;
	}

	/**
	 * Flush the binary output stream, padding 0s if number of bits written so
	 * far is not a multiple of 8.
	 */
	public void flush() {
		clearBuffer();
		try {
			out.flush();
		} catch (IOException e) {
			e.printStackTrace();
		}
	}

	/**
	 * Close and flush the binary output stream. Once it is closed, you can no
	 * longer write bits.
	 */
	public void close() {
		flush();
		try {
			out.close();
		} catch (IOException e) {
			e.printStackTrace();
		}
	}

	/**
	 * Write the specified bit to the binary output stream.
	 * 
	 * @param x
	 *            the <tt>boolean</tt> to write.
	 */
	public void write(boolean x) {
		writeBit(x);
	}

	/**
	 * Write the 8-bit byte to the binary output stream.
	 * 
	 * @param x
	 *            the <tt>byte</tt> to write.
	 */
	public void write(byte x) {
		writeByte(x & 0xff);
	}

	/**
	 * Write the 32-bit int to the binary output stream.
	 * 
	 * @param x
	 *            the <tt>int</tt> to write.
	 */
	public void write(int x) {
		writeByte((x >>> 24) & 0xff);
		writeByte((x >>> 16) & 0xff);
		writeByte((x >>> 8) & 0xff);
		writeByte((x >>> 0) & 0xff);
	}

	/**
	 * Write the r-bit int to the binary output stream.
	 * 
	 * @param x
	 *            the <tt>int</tt> to write.
	 * @param r
	 *            the number of relevant bits in the char.
	 * @throws RuntimeException
	 *             if <tt>r</tt> is not between 1 and 32.
	 * @throws RuntimeException
	 *             if <tt>x</tt> is not between 0 and 2<sup>r</sup> - 1.
	 */
	public void write(int x, int r) {
		if (r == 32)
			write(x);
		if (r < 1 || r > 32)
			throw new RuntimeException("Illegal value for r = " + r);
		if (x < 0 || x >= (1 << r))
			throw new RuntimeException("Illegal " + r + "-bit char = " + x);
		for (int i = 0; i < r; i++) {
			boolean bit = ((x >>> (r - i - 1)) & 1) == 1;
			writeBit(bit);
		}
	}

	/**
	 * Write the 64-bit double to the binary output stream.
	 * 
	 * @param x
	 *            the <tt>double</tt> to write.
	 */
	public void write(double x) {
		write(Double.doubleToRawLongBits(x));
	}

	/**
	 * Write the 64-bit long to the binary output stream.
	 * 
	 * @param x
	 *            the <tt>long</tt> to write.
	 */
	public void write(long x) {
		writeByte((int) ((x >>> 56) & 0xff));
		writeByte((int) ((x >>> 48) & 0xff));
		writeByte((int) ((x >>> 40) & 0xff));
		writeByte((int) ((x >>> 32) & 0xff));
		writeByte((int) ((x >>> 24) & 0xff));
		writeByte((int) ((x >>> 16) & 0xff));
		writeByte((int) ((x >>> 8) & 0xff));
		writeByte((int) ((x >>> 0) & 0xff));
	}

	/**
	 * Write the 32-bit float to the binary output stream.
	 * 
	 * @param x
	 *            the <tt>float</tt> to write.
	 */
	public void write(float x) {
		write(Float.floatToRawIntBits(x));
	}

	/**
	 * Write the 16-bit int to the binary output stream.
	 * 
	 * @param x
	 *            the <tt>short</tt> to write.
	 */
	public void write(short x) {
		writeByte((x >>> 8) & 0xff);
		writeByte((x >>> 0) & 0xff);
	}

	/**
	 * Write the 8-bit char to the binary output stream.
	 * 
	 * @param x
	 *            the <tt>char</tt> to write.
	 * @throws RuntimeException
	 *             if <tt>x</tt> is not betwen 0 and 255.
	 */
	public void write(char x) {
		if (x < 0 || x >= 256)
			throw new RuntimeException("Illegal 8-bit char = " + x);
		writeByte(x);
	}

	/**
	 * Write the r-bit char to the binary output stream.
	 * 
	 * @param x
	 *            the <tt>char</tt> to write.
	 * @param r
	 *            the number of relevant bits in the char.
	 * @throws RuntimeException
	 *             if <tt>r</tt> is not between 1 and 16.
	 * @throws RuntimeException
	 *             if <tt>x</tt> is not between 0 and 2<sup>r</sup> - 1.
	 */
	public void write(char x, int r) {
		if (r == 8)
			write(x);
		if (r < 1 || r > 16)
			throw new RuntimeException("Illegal value for r = " + r);
		if (x < 0 || x >= (1 << r))
			throw new RuntimeException("Illegal " + r + "-bit char = " + x);
		for (int i = 0; i < r; i++) {
			boolean bit = ((x >>> (r - i - 1)) & 1) == 1;
			writeBit(bit);
		}
	}

	/**
	 * Write the string of 8-bit characters to the binary output stream.
	 * 
	 * @param s
	 *            the <tt>String</tt> to write.
	 * @throws RuntimeException
	 *             if any character in the string is not between 0 and 255.
	 */
	public void write(String s) {
		for (int i = 0; i < s.length(); i++)
			write(s.charAt(i));
	}

	/**
	 * Write the String of r-bit characters to the binary output stream.
	 * 
	 * @param s
	 *            the <tt>String</tt> to write.
	 * @param r
	 *            the number of relevants bits in each character.
	 * @throws RuntimeException
	 *             if r is not between 1 and 16.
	 * @throws RuntimeException
	 *             if any character in the string is not between 0 and
	 *             2<sup>r</sup> - 1.
	 */
	public void write(String s, int r) {
		for (int i = 0; i < s.length(); i++)
			write(s.charAt(i), r);
	}

	/**
	 * Test client. Read bits from standard input and write to the file
	 * specified on command line.
	 */
	public static void main(String[] args) {

		// create binary output stream to write to file
		String filename = args[0];
		BinaryOut out = new BinaryOut(filename);
		BinaryIn in = new BinaryIn();

		// read from standard input and write to file
		while (!in.isEmpty()) {
			char c = in.readChar();
			out.write(c);
		}
		out.flush();
	}

}
